package com.tuyan.aixiang.util;


import android.content.Context;
import android.content.ContextWrapper;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.media.MediaPlayer;
import android.net.Uri;
import android.text.TextUtils;
import android.webkit.MimeTypeMap;

import com.tuyan.aixiang.BuildConfig;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Locale;

/**
 * Created by Tim on 16/8/27.
 */
public class FileHelper {
    private static final String TAG = "FileHelper";

    public static String getFileName(File file) {
        int end = file.getName().lastIndexOf(".");
        if (end == -1) return file.getName();
        return file.getName().substring(0, end);
    }

    public static String getExtension(String path) {
        return path.substring(path.lastIndexOf(".") + 1);
    }

    public static String getMimeType(Context ctx, File file) {
        String extension = getExtension(file.getPath());
        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension.toLowerCase());
    }

    public static boolean isVideoFile(String suffix) {
        String mime = MimeTypeMap.getSingleton().getMimeTypeFromExtension(suffix.toLowerCase());
        if (mime == null) return false;
        return mime.indexOf("video") != -1;
    }

    public static boolean isAudioFile(String suffix) {
        String mime = MimeTypeMap.getSingleton().getMimeTypeFromExtension(suffix.toLowerCase());
        if (mime == null) return false;
        return mime.indexOf("audio") != -1;
    }


    public static Bitmap getBitmapByResId(Context context, int resid) {
        Drawable drawable = context.getResources().getDrawable(resid);
        Bitmap bm = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config
                .ARGB_8888);
        Canvas canvas = new Canvas(bm);
        drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
        drawable.draw(canvas);
        return bm;
    }

    /**
     * 转换文件大小
     *
     * @param fileS
     * @return
     */
    public static String toSize(long fileS) {
        DecimalFormat df = new DecimalFormat("#.00");
        String fileSizeString = "";
        String wrongSize = "0B";
        if (fileS == 0) {
            return wrongSize;
        }
        if (fileS < 1024) {
            fileSizeString = df.format((double) fileS) + "B";
        } else if (fileS < 1048576L) {
            fileSizeString = df.format((double) fileS / 1024) + "KB";
        } else if (fileS < 1073741824L) {
            fileSizeString = df.format((double) fileS / 1048576L) + "MB";
        } else {
            fileSizeString = df.format((double) fileS / 1073741824L) + "GB";
        }
        return fileSizeString;
    }

    /**
     * 时长->转换为时分秒格式hh:mm:ss
     *
     * @param time
     * @return
     */
    public static String toDuration(int time) {
        time /= 1000;
        int minute = time / 60;
        int hour = minute / 60;
        int second = time % 60;
        minute %= 60;
        if (hour > 0) {
            return String.format(Locale.getDefault(), "%02d:%02d:%02d", hour, minute, second);
        } else {
            return String.format(Locale.getDefault(), "%02d:%02d", minute, second);
        }
    }

    /**
     * 日期
     *
     * @param path
     * @return
     */
    public static String getLastModified(String path) {
        File file = new File(path);
        if (!file.exists()) return "";
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(file.lastModified());
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault());
        return format.format(calendar.getTime());
    }

    /**
     * @param list
     * @param asc  升序
     */
    public static void sortByName(List<File> list, final boolean asc) {
        Collections.sort(list, new Comparator<File>() {
            @Override
            public int compare(File left, File right) {
                if (left != null && right != null) {
                    String current = asc ? left.getName() : right.getName();
                    String other = asc ? right.getName() : left.getName();

                    return current.compareToIgnoreCase(other);
                }
                return 0;
            }
        });
    }

    /**
     * 得到文件夹下过滤后的文件数组
     */
    public static String[] getFilesOfFolder(String fileStr, final String... suffix) {
        String[] result = null;
        File file = new File(fileStr);
        if (file.isDirectory()) {
            File[] fileArray = file.listFiles(getNameFilter(suffix));
            if (null != fileArray && 0 != fileArray.length) {
                result = new String[fileArray.length];
                for (int i = 0; i < fileArray.length; i++) {
                    String path = fileArray[i].getAbsolutePath();
//                    IbrLog.printI(FileUtils.class, "path:" + path);
                    result[i] = path;
                }

            }

        }

        return result;
    }

    /**
     * 筛选文件
     *
     * @param suffix 文件后缀{".txt",".doc"}
     * @return
     */
    public static FilenameFilter getNameFilter(final String... suffix) {
        return new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                if (suffix == null || suffix.length == 0) return true;
                int index = name.lastIndexOf('.');
                if (index <= 0) {
                    return false;
                }
                boolean meet = false;
                String type = name.substring(index);
                for (String item : suffix) {
                    if (item.equalsIgnoreCase(type)) {
                        meet = true;
                        break;
                    }
                }
                return meet;
            }
        };
    }

    /**
     * 递归删除目录下的所有文件及子目录下所有文件
     *
     * @param dir 将要删除的文件目录
     * @return boolean Returns "true" if all deletions were successful.
     * If a deletion fails, the method stops attempting to
     * delete and returns "false".
     */
    public static boolean deleteDir(File dir) {
        if (dir.isDirectory()) {
            String[] children = dir.list();
            //递归删除目录中的子目录下
            for (int i = 0; i < children.length; i++) {
                boolean success = deleteDir(new File(dir, children[i]));
                if (!success) {
                    return false;
                }
            }
        }
        // 目录此时为空，可以删除
        return dir.delete();
    }

    /**
     * 删除单个文件
     *
     * @param sPath 被删除文件的文件名
     * @return 单个文件删除成功返回true，否则返回false
     */
    public static boolean deleteFile(String sPath) {
        if (TextUtils.isEmpty(sPath)) {
            return false;
        }
        boolean flag = false;
        File file = new File(sPath);
        // 路径为文件且不为空则进行删除
        if (file.isFile() && file.exists()) {
            file.delete();
            flag = true;
        }
        return flag;
    }

    /**
     * 删除单个文件
     */
    public static boolean deleteFile(File file) {
        if (file != null) {
            // 路径为文件且不为空则进行删除
            if (file.isFile() && file.exists()) {
                return file.delete();
            }
        }
        return false;
    }

    /**
     * 判断文件是否存在
     *
     * @param fileStr
     * @return
     */
    public static boolean fileExist(String fileStr) {
        File file = new File(fileStr);
        return file.isFile() && file.exists();
    }

    /**
     * 创建文件夹，不存在就创建，多层文件夹没有也可创建
     *
     * @param path
     */
    public static boolean pathExistOrCreate(String path) {
        File pathFile = new File(path);
        boolean has = true;
        if (!pathFile.exists()) {
            has = pathFile.mkdirs();
            if (!has) {
//                System.exit(0);
                if (BuildConfig.DEBUG) {
                    ToastUtil.makeShort("文件夹创建失败" + path);
                }
            }
        }
        return has;
    }

    /**
     * 重命名的文件或文件夹
     *
     * @param oldFileStr
     * @param newFileStr
     * @return
     */
    public static boolean reNameFile(String oldFileStr, String newFileStr) {
        File oleFile = new File(oldFileStr); //要重命名的文件或文件夹
        File newFile = new File(newFileStr);  //重命名为zhidian1
        return oleFile.renameTo(newFile);  //执行重命名
    }

    /**
     * 得到音频文件播放时长
     *
     * @param fullName
     * @return
     */
    public static int getAudioDuration(String fullName) {
        String suffix = FileHelper.getExtension(fullName);
        if (!isAudioFile(suffix)) {
//            // TLog.printE(FileHelper.class, "getDuration 不是声音文件");
            return -1;
        }
        MediaPlayer mp = new MediaPlayer();
        int duration = -1;
        try {
            mp.setDataSource(fullName);
            mp.prepare();
            duration = mp.getDuration();
//            // TLog.printE(FileHelper.class, "getDuration", duration, fullName);

        } catch (Exception e) {
            e.printStackTrace();
        }
        mp.stop();
        mp.release();
        return duration;
    }

    /**
     * 获取文件最后修改时间
     *
     * @param fullName
     * @return
     */
    public static String getFileModifiedTime(String fullName) {
        File file = new File(fullName);
        long modifiedTime = file.lastModified();// 毫秒数
        return DateUtil.format(new Date(modifiedTime), "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 获取url中图片的后缀，不是图片的返回null
     *
     * @param url
     * @return
     */
    public static String getImageSuffix(String url) {
        String lowerCaseUrl = url.toLowerCase();
        String extName = null;
        if (lowerCaseUrl.contains(".jpg")) {
            extName = ".jpg";
        } else if (lowerCaseUrl.contains(".jpeg")) {
            extName = ".jpeg";
        } else if (lowerCaseUrl.contains(".png")) {
            extName = ".png";
        } else if (lowerCaseUrl.contains(".bmp")) {
            extName = ".bmp";
        } else if (lowerCaseUrl.contains(".gif")) {
            extName = ".gif";

        }
        return extName;
    }

    /**
     * 复制单个文件 resource-源文件，target-目标文件
     */
    public static void copyFile(File source, File target) {
        if (source == null) {
            return;
        }
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream(source));
            bos = new BufferedOutputStream(new FileOutputStream(target));
            byte[] b = new byte[1024 * 5];
            int length;
            while ((length = bis.read(b)) != -1) {
                bos.write(b, 0, length);
            }
            bos.flush();
        } catch (Exception e) {
            return;
        } finally {
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 通知系统相册更新的
     *
     * @param contextWrapper
     * @param imageFile      是图片的File对象
     */
    public static void notify(ContextWrapper contextWrapper, File imageFile) {
        Uri localUri = Uri.fromFile(imageFile);
        Intent localIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, localUri);
        contextWrapper.sendBroadcast(localIntent);
    }

    /**
     * 创建文件，多层文件夹没有也可创建，有或者创建成功返回true
     *
     * @param destFileName
     * @return
     */
    public static boolean createFile(String destFileName) {
        File file = new File(destFileName);
        if (file.exists()) {
//            // TLog.printE(FileHelper.class, "创建单个文件" + destFileName + "失败，目标文件已存在！");
            return true;
        }
        if (destFileName.endsWith(File.separator)) {
//            // TLog.printE(FileHelper.class, "创建单个文件" + destFileName + "失败，目标文件不能为目录！");
            return false;
        }
        //判断目标文件所在的目录是否存在
        if (!file.getParentFile().exists()) {
            //如果目标文件所在的目录不存在，则创建父目录
//            // TLog.printE(FileHelper.class, "目标文件所在目录不存在，准备创建它！");
            if (!file.getParentFile().mkdirs()) {
//                // TLog.printE(FileHelper.class, "创建目标文件所在目录失败！");
                return false;
            }
        }
        //创建目标文件
        try {
            if (file.createNewFile()) {
//                // TLog.printE(FileHelper.class, "创建单个文件" + destFileName + "成功！");
                return true;
            } else {
//                // TLog.printE(FileHelper.class, "创建单个文件" + destFileName + "失败！");
                return false;
            }
        } catch (IOException e) {
            e.printStackTrace();
//            // TLog.printE(FileHelper.class, "创建单个文件" + destFileName + "失败！" + e.getMessage());
            return false;
        }
    }


    /**
     * 创建文件夹，多层文件夹没有也可创建，有或创建成功返回true
     *
     * @param destDirName
     * @return
     */
    public static boolean createDir(String destDirName) {
        File dir = new File(destDirName);
        if (dir.exists()) {
//            // TLog.printE(FileHelper.class, "创建目录" + destDirName + "失败，目标目录已经存在");
            return true;
        }
        if (!destDirName.endsWith(File.separator)) {
            destDirName = destDirName + File.separator;
        }
        //创建目录
        if (dir.mkdirs()) {
            // TLog.printE(FileHelper.class, "创建目录" + destDirName + "成功！");
            return true;
        } else {
            // TLog.printE(FileHelper.class, "创建目录" + destDirName + "失败！");
            return false;
        }
    }

    /**
     * 一次性读取文件，转换成字符串。
     *
     * @param fullName 文件全路径
     */
    public static String readFiletoStr(String fullName) {
        return readFiletoStr(new File(fullName));
    }

    /**
     * 一次性读取文件，转换成字符串。
     *
     * @param file
     */
    public static String readFiletoStr(File file) {
        if (!file.exists()) {
            return null;
        }
        try {
            Long fileLens = file.length();
            byte[] content = new byte[fileLens.intValue()];

            FileInputStream fs = null;
            fs = new FileInputStream(file);
            fs.read(content);
            fs.close();
            String s = new String(content, "UTF-8");
            // TLog.printE(FileHelper.class, "readFiletoStr", s);
            return s;
        } catch (Exception e) {
            // TLog.printE(FileHelper.class, "readFiletoStr", e);
            e.printStackTrace();
        }
        return null;
    }

//    /**
//     * 判读缓存图片是否存在。
//     *
//     * @param url
//     * @return
//     */
//    public static boolean picCacheExist(String url) {
//        return picCacheExist(url, FileHelper.getImageSuffix(url));
//    }
////
//    /**
//     * 判读缓存图片是否存在。
//     *
//     * @param url
//     * @param extName
//     * @return
//     */
//    public static boolean picCacheExist(String url, String extName) {
//        String name = EncryUtil.Md5(url) + extName;
//        File file = new File(ConfigData.PATH_DCIM + File.separator + name);
//        return file.exists();
//    }
//
//    /**
//     * 得到缓存文件。
//     *
//     * @param url
//     * @return
//     */
//    public static File getPicCacheFile(String url) {
//        return getPicCacheFile(url, FileHelper.getImageSuffix(url));
//    }

//    /**
//     * 得到缓存文件。
//     *
//     * @param url
//     * @param extName
//     * @return
//     */
//    public static File getPicCacheFile(String url, String extName) {
//        String name = EncryUtil.Md5(url) + extName;
//        try {
//            // 检测DCIM文件夹是否存在，不存在就创建
//            boolean ok = FileHelper.pathExistOrCreate(ConfigData.PATH_DCIM);
//            if (ok) {
//                File file = new File(ConfigData.PATH_DCIM + File.separator + name);
//                return file;
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return null;
//    }

    /**
     * 获取音视频的播放时长
     *
     * @param file 文件的路径
     */
    public static int getRecordFileDuration(String file) {
        MediaPlayer player = new MediaPlayer();
        try {
            player.setDataSource(file);
            player.prepare();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        int duration = player.getDuration();//获取音频的时间
        // TLog.printE(FileHelper.class, "getRecordFileDuration: " + duration);
        player.release();//记得释放资源
        return duration;
    }
}